{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=5\n",
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True\n",
    "#equation_component_combination = [1.0,2.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Noise 15%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1] + np.random.normal(loc=0.0, scale=0.15, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.15658 | domain_loss:  557.84418 | bdc_loss:    0.58398\n",
      "epoch:  200.00000 | total_loss:    0.90278 | domain_loss:   38.97577 | bdc_loss:    0.51821\n",
      "epoch:  400.00000 | total_loss:    0.54627 | domain_loss:    8.76604 | bdc_loss:    0.46325\n",
      "epoch:  600.00000 | total_loss:    0.44337 | domain_loss:    3.48957 | bdc_loss:    0.41260\n",
      "epoch:  800.00000 | total_loss:    0.37945 | domain_loss:    1.89766 | bdc_loss:    0.36412\n",
      "epoch: 1000.00000 | total_loss:    0.32764 | domain_loss:    1.20773 | bdc_loss:    0.31875\n",
      "epoch: 1200.00000 | total_loss:    0.28525 | domain_loss:    0.81327 | bdc_loss:    0.27991\n",
      "epoch: 1400.00000 | total_loss:    0.25439 | domain_loss:    0.55352 | bdc_loss:    0.25137\n",
      "epoch: 1600.00000 | total_loss:    0.23567 | domain_loss:    0.38396 | bdc_loss:    0.23417\n",
      "epoch: 1800.00000 | total_loss:    0.22616 | domain_loss:    0.28084 | bdc_loss:    0.22561\n",
      "epoch: 2000.00000 | total_loss:    0.22155 | domain_loss:    0.22156 | bdc_loss:    0.22155\n",
      "epoch: 2200.00000 | total_loss:    0.21877 | domain_loss:    0.19002 | bdc_loss:    0.21906\n",
      "epoch: 2400.00000 | total_loss:    0.21646 | domain_loss:    0.17705 | bdc_loss:    0.21686\n",
      "epoch: 2600.00000 | total_loss:    0.21415 | domain_loss:    0.17751 | bdc_loss:    0.21452\n",
      "epoch: 2800.00000 | total_loss:    0.21170 | domain_loss:    0.18855 | bdc_loss:    0.21193\n",
      "epoch: 3000.00000 | total_loss:    0.20901 | domain_loss:    0.20882 | bdc_loss:    0.20901\n",
      "epoch: 3200.00000 | total_loss:    0.20600 | domain_loss:    0.23807 | bdc_loss:    0.20568\n",
      "epoch: 3400.00000 | total_loss:    0.20260 | domain_loss:    0.27700 | bdc_loss:    0.20185\n",
      "epoch: 3600.00000 | total_loss:    0.19870 | domain_loss:    0.32705 | bdc_loss:    0.19741\n",
      "epoch: 3800.00000 | total_loss:    0.19419 | domain_loss:    0.39029 | bdc_loss:    0.19221\n",
      "epoch: 4000.00000 | total_loss:    0.18893 | domain_loss:    0.46930 | bdc_loss:    0.18610\n",
      "epoch: 4200.00000 | total_loss:    0.18277 | domain_loss:    0.56669 | bdc_loss:    0.17889\n",
      "epoch: 4400.00000 | total_loss:    0.17556 | domain_loss:    0.68437 | bdc_loss:    0.17042\n",
      "epoch: 4600.00000 | total_loss:    0.16718 | domain_loss:    0.82208 | bdc_loss:    0.16057\n",
      "epoch: 4800.00000 | total_loss:    0.15759 | domain_loss:    0.97535 | bdc_loss:    0.14933\n",
      "epoch: 5000.00000 | total_loss:    0.14686 | domain_loss:    1.13364 | bdc_loss:    0.13689\n",
      "epoch: 5200.00000 | total_loss:    0.13526 | domain_loss:    1.28026 | bdc_loss:    0.12370\n",
      "epoch: 5400.00000 | total_loss:    0.12328 | domain_loss:    1.39581 | bdc_loss:    0.11043\n",
      "epoch: 5600.00000 | total_loss:    0.11160 | domain_loss:    1.46524 | bdc_loss:    0.09792\n",
      "epoch: 5800.00000 | total_loss:    0.10099 | domain_loss:    1.48551 | bdc_loss:    0.08700\n",
      "epoch: 6000.00000 | total_loss:    0.09210 | domain_loss:    1.46772 | bdc_loss:    0.07820\n",
      "epoch: 6200.00000 | total_loss:    0.08521 | domain_loss:    1.43090 | bdc_loss:    0.07162\n",
      "epoch: 6400.00000 | total_loss:    0.08019 | domain_loss:    1.39208 | bdc_loss:    0.06694\n",
      "epoch: 6600.00000 | total_loss:    0.07662 | domain_loss:    1.36051 | bdc_loss:    0.06366\n",
      "epoch: 6800.00000 | total_loss:    0.07403 | domain_loss:    1.33841 | bdc_loss:    0.06126\n",
      "epoch: 7000.00000 | total_loss:    0.07202 | domain_loss:    1.32467 | bdc_loss:    0.05937\n",
      "epoch: 7200.00000 | total_loss:    0.07032 | domain_loss:    1.31768 | bdc_loss:    0.05772\n",
      "epoch: 7400.00000 | total_loss:    0.06876 | domain_loss:    1.31648 | bdc_loss:    0.05616\n",
      "epoch: 7600.00000 | total_loss:    0.06723 | domain_loss:    1.32064 | bdc_loss:    0.05457\n",
      "epoch: 7800.00000 | total_loss:    0.06564 | domain_loss:    1.32969 | bdc_loss:    0.05287\n",
      "epoch: 8000.00000 | total_loss:    0.06393 | domain_loss:    1.34271 | bdc_loss:    0.05101\n",
      "epoch: 8200.00000 | total_loss:    0.06201 | domain_loss:    1.35795 | bdc_loss:    0.04892\n",
      "epoch: 8400.00000 | total_loss:    0.05982 | domain_loss:    1.37236 | bdc_loss:    0.04656\n",
      "epoch: 8600.00000 | total_loss:    0.05724 | domain_loss:    1.38151 | bdc_loss:    0.04387\n",
      "epoch: 8800.00000 | total_loss:    0.05423 | domain_loss:    1.38029 | bdc_loss:    0.04084\n",
      "epoch: 9000.00000 | total_loss:    0.05073 | domain_loss:    1.36285 | bdc_loss:    0.03747\n",
      "epoch: 9200.00000 | total_loss:    0.04670 | domain_loss:    1.32075 | bdc_loss:    0.03383\n",
      "epoch: 9400.00000 | total_loss:    0.04214 | domain_loss:    1.24209 | bdc_loss:    0.03002\n",
      "epoch: 9600.00000 | total_loss:    0.03712 | domain_loss:    1.11384 | bdc_loss:    0.02624\n",
      "epoch: 9800.00000 | total_loss:    0.03182 | domain_loss:    0.93065 | bdc_loss:    0.02274\n",
      "epoch: 10000.00000 | total_loss:    0.02654 | domain_loss:    0.70621 | bdc_loss:    0.01968\n",
      "epoch: 10200.00000 | total_loss:    0.02153 | domain_loss:    0.47374 | bdc_loss:    0.01696\n",
      "epoch: 10400.00000 | total_loss:    0.01659 | domain_loss:    0.26641 | bdc_loss:    0.01406\n",
      "epoch: 10600.00000 | total_loss:    0.00944 | domain_loss:    0.03718 | bdc_loss:    0.00916\n",
      "epoch: 10800.00000 | total_loss:    0.00528 | domain_loss:    0.00000 | bdc_loss:    0.00534\n",
      "epoch: 11000.00000 | total_loss:    0.00382 | domain_loss:    0.00000 | bdc_loss:    0.00386\n",
      "epoch: 11200.00000 | total_loss:    0.00295 | domain_loss:    0.00000 | bdc_loss:    0.00298\n",
      "epoch: 11400.00000 | total_loss:    0.00232 | domain_loss:    0.00000 | bdc_loss:    0.00235\n",
      "epoch: 11600.00000 | total_loss:    0.00183 | domain_loss:    0.00000 | bdc_loss:    0.00185\n",
      "epoch: 11800.00000 | total_loss:    0.00144 | domain_loss:    0.00000 | bdc_loss:    0.00145\n",
      "epoch: 12000.00000 | total_loss:    0.00111 | domain_loss:    0.00000 | bdc_loss:    0.00112\n",
      "epoch: 12200.00000 | total_loss:    0.00085 | domain_loss:    0.00000 | bdc_loss:    0.00086\n",
      "epoch: 12400.00000 | total_loss:    0.00064 | domain_loss:    0.00000 | bdc_loss:    0.00065\n",
      "epoch: 12600.00000 | total_loss:    0.00049 | domain_loss:    0.00000 | bdc_loss:    0.00049\n",
      "epoch: 12800.00000 | total_loss:    0.00037 | domain_loss:    0.00000 | bdc_loss:    0.00037\n",
      "epoch: 13000.00000 | total_loss:    0.00028 | domain_loss:    0.00000 | bdc_loss:    0.00028\n",
      "epoch: 13200.00000 | total_loss:    0.00021 | domain_loss:    0.00000 | bdc_loss:    0.00022\n",
      "epoch: 13400.00000 | total_loss:    0.00016 | domain_loss:    0.00000 | bdc_loss:    0.00017\n",
      "epoch: 13600.00000 | total_loss:    0.00013 | domain_loss:    0.00000 | bdc_loss:    0.00013\n",
      "epoch: 13800.00000 | total_loss:    0.00009 | domain_loss:    0.00000 | bdc_loss:    0.00010\n",
      "epoch: 14000.00000 | total_loss:    0.00007 | domain_loss:    0.00000 | bdc_loss:    0.00007\n",
      "epoch: 14200.00000 | total_loss:    0.00005 | domain_loss:    0.00000 | bdc_loss:    0.00005\n",
      "epoch: 14400.00000 | total_loss:    0.00003 | domain_loss:    0.00000 | bdc_loss:    0.00003\n",
      "epoch: 14600.00000 | total_loss:    0.00002 | domain_loss:    0.00000 | bdc_loss:    0.00002\n",
      "epoch: 14800.00000 | total_loss:    0.00001 | domain_loss:    0.00000 | bdc_loss:    0.00001\n",
      "epoch: 15000.00000 | total_loss:    0.00001 | domain_loss:    0.00000 | bdc_loss:    0.00001\n",
      "epoch: 15200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 17600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19200.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 19800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_7/kernel:0' shape=(1, 1, 2, 1) dtype=float32, numpy=\n",
       " array([[[[0.00000e+00],\n",
       "          [4.37726e-37]]]], dtype=float32)>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99776625"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.19955325*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0),\n",
    "                     'k1':pde_model_train.layers[-6].weights[0][0,0,0,0].numpy(),\n",
    "                     'k2':pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.37726e-37"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zengz\\AppData\\Local\\Temp/ipykernel_9924/728528382.py:1: RuntimeWarning: divide by zero encountered in float_scalars\n",
      "  pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zengz\\AppData\\Local\\Temp/ipykernel_9924/538172811.py:1: RuntimeWarning: divide by zero encountered in float_scalars\n",
      "  (pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
